home *** CD-ROM | disk | FTP | other *** search
/ Mac Mania 2 / MacMania 2.toast / Demo's / Tools&Utilities / Programming / MSTPChart / MacSciTechDemo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-26  |  22.3 KB  |  592 lines  |  [TEXT/KAHL]
  1. /*
  2. •        This THINK C source code, project file, and resource file were created by
  3. •        Dr. Craig Stone, Professor of Nuclear Chemistry at San Jose State
  4. •        University, California USA, for the Macintosh Scientific and Technical
  5. •        Users Association (MacSciTech), to accompany his article "Quickstart
  6. •        Macintosh Programming" which appeared in the SciTech Journal of May, 1993.
  7. •        Supplemental commenting was added by MacSciTech. The author
  8. •        can be reached on Applelink at Stone.C. MacSciTech can be reached on
  9. •        Applelink at MacSciTech, on America Online at SciTechMac, and on the
  10. •        Internet at SciTechMac@aol.com or attila.nrl.navy.mil. You are encouraged
  11. •        to use, modify, and improve this source code without restriction. If you
  12. •        distribute this source code essentially unmodified and for public
  13. •        consumption (e.g., you post it to a BBS), MacSciTech does request that
  14. •        you leave the comments intact and keep all the project files together:
  15. •
  16. •        About.c
  17. •        Elements.c
  18. •        MacSciTechDemo.c
  19. •        MenuControl.c
  20. •        Periodic.c
  21. •        WindowControl.c
  22. •        MST_Defines.h
  23. •        MST_Externs.h
  24. •        MST_Globals.h
  25. •        MST_Menus.h
  26. •        MST_Prototypes.h
  27. •        MSTPChart.π
  28. •        MSTPChart.π.rsrc
  29. •
  30. •        All functions are "marked," so you can quickly navigate to any function
  31. •        in a file by pressing the mouse down in the title bar of the source
  32. •        code window while holding down the command key. This presents you with
  33. •        a pop-up menu of all the functions. Similarly, all the include files
  34. •        are available by holding down the option key while pressing the mouse
  35. •        down in the title bar.
  36. •        
  37. */ 
  38.  
  39.  
  40.  
  41. /*
  42. •        This file contains the function "main", which is the point at which
  43. •        our program begins execution.
  44. */
  45.  
  46. /*
  47. •        We include two files up front. The file MST_Defines.h contains our constants.
  48. •        MST_Globals.h defines (i.e., declares the type of and allocates
  49. •        storage for) our global variables.
  50. */
  51.  
  52. #include    "MST_Defines.h"
  53. #include    "MST_Globals.h"
  54.  
  55.  
  56. void    Init_Variables    (void); /*Declare Init_Variables() here for aesthetic reasons:*/
  57.                                 /*main() can refer to it, yet we can place main() at*/
  58.                                 /*the top of the source file where it is handy.*/
  59.                                 
  60.  
  61. /*_____________________________________________________________________________
  62.                         main()- main program
  63. _____________________________________________________________________________*/
  64.  
  65. void main() 
  66. {
  67.  
  68. /*
  69. •    Any program does two things. It initializes itself, and then enters into
  70. •    an event loop until the user asks it to quit. Often the main() function
  71. •    of a program places the initialization routines in a separate source
  72. •    code file, and the event loop in another file, so that the main()
  73. •    code is exceptionally short. Since our program is not very complex, we
  74. •    will keep most of the initialization and the event loop in main().
  75. •
  76. •    Here we declare our variables for main(). The variables are:
  77. •
  78. •    stillInGoAway    
  79. •    thisChar        
  80. •    thisCode        
  81. •    thisMenu        
  82. •    thisItem        
  83. •    MainKey            
  84. •    thisResult        Store information about the menu item selected here
  85. •    thisRect        A boundary rectangle so we cannot drag our window off the screen
  86. •    theInput        
  87. •    thisEvent        
  88. •    thisWindow        
  89. */
  90.  
  91.     char            stillInGoAway,    thisChar;
  92.     short            thisCode,        thisMenu,    thisItem,    MainKey;
  93.     long            thisResult;
  94.     Rect            thisRect;
  95.     TEHandle        theInput;
  96.     EventRecord        thisEvent;
  97.     WindowPtr        thisWindow;
  98. /*
  99.  •        ----------------------------Program Initialization----------------------
  100.  •        First, we have to initialize all the Macintosh Toolbox Managers that we
  101.  •        will need. These initializations MUST be performed once, and ONLY once,
  102.  •        in your application. You would NOT initialize the managers if you were
  103.  •        writing a piece of code, such as an XCMD or INIT, which is not a
  104.  •        stand-alone application. It is also customary to flush any events which
  105.  •        may be pending in the event queue. These Toolbox initialization calls should
  106.  •        appear in exactly the order shown below.
  107.  •
  108.  */    
  109.     InitGraf    (&thePort);            /*Initialize Quickdraw*/
  110.     InitFonts    ();                    /*Initialize the Font Manager*/
  111.     FlushEvents    (everyEvent,0);
  112.     InitWindows    ();                    /*Initialize the Window Manager*/
  113.     InitMenus    ();                    /*Initialize the Menu Manager*/
  114.     TEInit        ();                    /*Initialize TextEdit*/
  115.     InitDialogs    (NIL);                /*Initialize the Dialog Manager*/
  116.     InitCursor    ();                    /*Initialize the cursor*/
  117. /*
  118.  •
  119.  •        Next we do whatever initialization is peculiar to our program. In our
  120.  •        case, we set up our menus and initialize our global and main() variables.
  121.  •        Init_ApplicationMenus() is in the file MenuControl.c, while Init_Variables()
  122.  •        is listed in this file after main().
  123.  •
  124.  */    
  125.     Init_ApplicationMenus();
  126.     Init_Variables();
  127.     Init_Windows();
  128.  
  129.     Quitting     =    FALSE;        /*We don't want to quit yet!*/
  130.     theInput         =    NIL;
  131.     
  132. /*
  133.  •        
  134.  •        Typically a program would also at this point find out information about
  135.  •        the hardware and system software environment currently running it. This
  136.  •        information is necessary so the program can either adjust to the
  137.  •        environment, or advise the user that it cannot adjust to the environment,
  138.  •        and gracefully quit.
  139.  •
  140.  •        For example, some things your program might want to know are: the number
  141.  •        of monitors, color/grayscale/monochrome, depth of color or grayscale,
  142.  •        ROM version, system version, and HFS or MFS file system.
  143.  •
  144.  •        Our program here assumes at least System 7 and a color monitor. A monochrome
  145.  •        monitor will not display the periodic table grid.
  146.  •        
  147. */
  148.  
  149. /*
  150.  •        ----------------------------Main Event Loop----------------------------
  151. */
  152.  
  153.     do
  154.     {
  155. /*
  156.  •        We call our function Do_TEIdle, which itself calls the Toolbox function
  157.  •        TEIdle so that any TextEdit insertion points will blink properly. We don't
  158.  •        have any need for this in this application. Here, we choose to remove all
  159.  •        functionality from Do_TEIdle() in WindowControl.c. Alternatively, we
  160.  •        could have just removed the call to Do_TEIdle() instead.
  161. */
  162.         Do_TEIdle    (theInput);
  163.  
  164. /*
  165.  •        Now call the Toolbox function WaitNextEvent, which is the core of every
  166.  •        Macintosh program. WaitNextEvent places the next event record into
  167.  •        thisEvent and pops that event off of the "First in, first out" event queue.
  168.  •        "everyEvent" is a system constant which tells WaitNextEvent we want to
  169.  •        retrieve all events, no matter what kind. Activate/deactivate events are
  170.  •        first priority, while update events are given last priority. (Update
  171.  •        events are generated by the system to tell us part of the screen needs
  172.  •        redrawing; activate/deactivate events tell us the front-most window
  173.  •        is changing.) 30 is the maximum number of ticks we are willing to be suspended
  174.  •        in the background without at least being passed a null event from the system.
  175.  */
  176.             
  177.  
  178.         if    (WaitNextEvent    (everyEvent,&thisEvent,30,NIL))
  179.         {
  180. /*
  181.  •        Now we determine what the user did, and respond accordingly. Constants
  182.  •        such as mouseDown and keyDown are defined by the Macintosh Toolbox. THINK C
  183.  •        implements them exactly as shown in Inside Macintosh, even though
  184.  •        the convention in C is to name constants in all upper case.
  185. */
  186.             thisCode = FindWindow    (thisEvent.where, &thisWindow);
  187.  
  188.             switch (thisEvent.what)
  189.             {
  190.                 case mouseDown:        /*If the event was a mousedown*/
  191.                 {
  192. /*
  193.  •        In what part of the screen or window did the mouse event occur?
  194.  •        (Toolbox constants for screen parts include: inMenuBar,
  195.  •        inDrag (the drag region of an application window), inGoAway (the
  196.  •        close box of an application window), inContent (in the content region
  197.  •        of an application window), and inSysWindow (in a desk accessory window)).
  198. */
  199.  
  200.                     if (thisCode == inMenuBar)
  201.                     {
  202. /*
  203.  •        If the mouseDown event was in the menubar, we decode it using the Toolbox
  204.  •        function MenuSelect, and pass the results to our menu handling routine.
  205.  •        MenuSelect also takes care of highlighting and flashing the menu items.
  206. */
  207.                         thisResult         =    MenuSelect(thisEvent.where);
  208.                         thisMenu        =    HiWord    (thisResult);
  209.                         thisItem        =    LoWord    (thisResult);
  210.                         Handle_TheMenus    (thisMenu,thisItem);
  211.                     }
  212.                     
  213.                     else    if ((thisCode == inDrag)&&(thisWindow != NIL))
  214.                     {
  215. /*
  216.  •        If the mouseDown event is in the drag region of the our window, we use
  217.  •        the Toolbox function DragWindow to drag it around, taking care not to
  218.  •        let the window get dragged completely to the edge of the screen.
  219.  •        This would need to be modified to handle multiple monitors.
  220. */
  221.                         thisRect.left    =    qd.screenBits.bounds.left    + 10;
  222.                         thisRect.right    =    qd.screenBits.bounds.right    - 10;
  223.                         thisRect.top    =    qd.screenBits.bounds.top    + 10;
  224.                         thisRect.bottom    =    qd.screenBits.bounds.bottom    - 10;
  225.                         DragWindow    (thisWindow, thisEvent.where, &thisRect);
  226.                     }
  227.                     
  228.                     else    if (thisCode == inGoAway)
  229.                     {
  230. /*
  231.  •        If the mouseDown was in the close box of the window, we monitor it with
  232.  •        the Toolbox function TrackGoAway. Like DragWindow, TrackGoAway does not
  233.  •        return until the mouse is released. TrackGoAway takes care of producing
  234.  •        the little starburst in the close box when the mouse is within the close
  235.  •        box, and removing the starburst when the mouse is outside the close box.
  236.  •        If the mouse is within the close box when the mouse is released,
  237.  •        TrackGoAway returns TRUE, in which case we call our routine to close
  238.  •        the window.
  239. */
  240.                         stillInGoAway = TrackGoAway(thisWindow,thisEvent.where);
  241.                         if (stillInGoAway == TRUE)    Close_Window    (thisWindow);
  242.                     }
  243.                     
  244.                     else    if (thisCode == inContent)
  245.                     {
  246. /*
  247.  •        If the mouseDown was in the content region of our window (as opposed to
  248.  •        its frame, or outside the window altogether) we make it active if it is
  249.  •        not already, and perform our window handling routines.
  250. */
  251.                         if (thisWindow != FrontWindow())    SelectWindow    (thisWindow);
  252.                         Do_Window        (thisWindow,&thisEvent);
  253.                         break;
  254.                     }
  255.  
  256.                     else    if (thisCode == inSysWindow)    SystemClick    (&thisEvent, thisWindow);
  257.                     break;
  258.                 }
  259. /*
  260.  •        Handle keyDown and autoKey events. Note that contrary to Listing 5 in
  261.  •        the original article, Do_PeriodicChart() is no longer responsible for
  262.  •        handling keyboard events. That is now the job of a new function, Do_Key().
  263.  •        When Do_PeriodicChart() handled both types of events, the program
  264.  •        inquired whether an event was a mouse event or keyboard event twice:
  265.  •        once in the main event loop, and once in the Do_PeriodicChart function.
  266.  •        Handling keyboard events in a separate function is a better arrangement.
  267. */
  268.                 case keyDown:
  269.                 case autoKey:
  270.                 {
  271.                     Do_Key    (FrontWindow(),&thisEvent);
  272.                     break;
  273.                 }
  274. /*
  275.  •        One of the most important parts of a program's code: Handle the Update Events.
  276. */
  277.                 case updateEvt:    
  278.                 {
  279.                     Update_Window    (&thisEvent);
  280.                     break;
  281.                 }
  282. /*
  283.  •        If there is a disk insertion event results in an error, we call the
  284.  •        Toolbox routine DIBadMount. This is the one you've seen which posts
  285.  •        alerts like "This disk is unreadable: Do you want to initialize it?"
  286.  •        followed by three buttons: Eject, One-Sided, and Two-Sided. The System
  287.  •        leaves it to the application to call DIBadMount so that disk utility
  288.  •        programs can handle bad disks with the "disk unreadable" alert being shown.
  289. */
  290.                 case diskEvt:
  291.                 {
  292.                     if (HiWord(thisEvent.message) != 0)
  293.                     { 
  294.                         thisEvent.where.h = ((qd.screenBits.bounds.right - qd.screenBits.bounds.left) / 2) - (304 / 2);
  295.                         thisEvent.where.v = ((qd.screenBits.bounds.bottom - qd.screenBits.bounds.top) / 3) - (104 / 2);
  296.                         InitCursor();
  297.                         thisItem = DIBadMount(thisEvent.where, thisEvent.message);
  298.                     }   
  299.                     break;
  300.                 }
  301. /*
  302.  •        And finally, we activate the window clicked in if it is an activate event
  303.  •        (as determined by testing the activeFlag bit in the modifiers field of
  304.  •        the event record). We have no housekeeping to do of any kind when
  305.  •        deactivating a window, so we have no deactivating routine. More complex
  306.  •        programs may need to do things like "unhighlight" the grow box in the
  307.  •        bottom right corner of a resizable window which is being deactivated.
  308. */
  309.                 case activateEvt:
  310.                 {
  311.                     SetCursor    (&(qd.arrow));
  312.                     if ((thisWindow != NIL) && (thisEvent.modifiers & activeFlag))
  313.                     { 
  314.                         Activate_Window    (thisWindow);
  315.                     }
  316.                     break;
  317.                 }
  318.                 
  319.                 default:    break;
  320.             }
  321.         }
  322.     }
  323.     while (Quitting ==  FALSE);
  324.     
  325. /*
  326. •        Upon reaching the end of our main() function, compiler-added code and
  327. •        the operating system work to clean up after us. Our application's space
  328. •        in RAM is deallocated, so that if we have open windows or other memory
  329. •        allocated, we do not need to explicitly call DisposDialog(), DisposHandle,
  330. •        etc., to free up those blocks of memory. (Note: there are Toolbox calls
  331. •        available to allocate memory from the system heap and free multifinder
  332. •        memory, and you must explicitly clean these up before quitting.) For
  333. •        applications which save information to files, you will need to create
  334. •        a scheme for tracking changes and saving data in variables and memory
  335. •        blocks to files before quitting. Stephen Chernicoff shows a good scheme
  336. •        for doing this in volume 2 of his four volume set "Macintosh Revealed,"
  337. •        published by Hayden Books. FYI, Macintosh Revealed is written in Pascal.
  338. */
  339.  
  340. }
  341.  
  342.                                     /*end main()*/
  343.                                     
  344. /*______________________________________________________________________________
  345.                             Init_Variables()- initialize program variables
  346. ______________________________________________________________________________*/
  347.  
  348.  
  349. void    Init_Variables()
  350. {
  351.     int        loop1;
  352.  
  353. /*
  354. •        Here we are just defining a few RGB (Red Green Blue) colors, as described
  355. •        in Inside Macintosh. This is really nothing to be concerned about at this
  356. •        point. We will, however, have to make sure we draw in black, not blue, if
  357. •        we are running on a monochrome monitor. (The blue is invisible on a monochrome
  358. •        monitor. Each variable of type RGBColor has a field to describe the
  359. •        intensity of the red, green, and blue. These variables (e.g., Color_Red)
  360. •        are our program's global variables which we defined in the file MST_Globals.h.
  361. */
  362.     Color_Red.red        =    65535;
  363.     Color_Red.green        =    0;
  364.     Color_Red.blue        =    0;
  365.  
  366.     Color_Blue.red        =    0;
  367.     Color_Blue.green    =    0;
  368.     Color_Blue.blue        =    65535;
  369.  
  370.     Color_Green.red        =    0;
  371.     Color_Green.green    =    65535;
  372.     Color_Green.blue    =    0;
  373.  
  374.     Color_Black.red        =    0;
  375.     Color_Black.green    =    0;
  376.     Color_Black.blue    =    0;
  377.  
  378.     Color_White.red        =    0;
  379.     Color_White.green    =    0;
  380.     Color_White.blue    =    0;
  381.  
  382.     Color_LtRed.red        =    65535;
  383.     Color_LtRed.green    =    32767;
  384.     Color_LtRed.blue    =    32767;
  385.  
  386.     Color_LtGreen.red    =    32767;
  387.     Color_LtGreen.green    =    65535;
  388.     Color_LtGreen.blue    =    32767;
  389.  
  390.     Color_LtBlue.red    =    32767;
  391.     Color_LtBlue.green    =    32767;
  392.     Color_LtBlue.blue    =    65535;
  393.     
  394. /*
  395.  •        Now we set up the coordinates for the rectangles we need to
  396.  •        draw the periodic chart. The coordinates are all local to the window
  397.  •        into which we will draw the chart; i.e., we will use the coordinates as
  398.  •        offsets down and to the right of the top left corner of the window. The
  399.  •        top left corner of the window is coordinate (0,0) in local coordinates.
  400.  •
  401.  •        PeriodicRects[] is a global variable array which we defined in MST_Globals.h.
  402.  •        Each array element is of type Rect, a Quickdraw struct defined in Inside
  403.  •        Macintosh consisting of four QuickDraw coordinates. The fields of a Rect are
  404.  •        top, left, bottom, and right.
  405.  •
  406.  •        Each element of the array has the same number as the atomic element it
  407.  •        corresponds to. We skip PeriodicRects[0] for this reason. BoxSize is a
  408.  •        constant defined in MST_Defines.h. In this way we can change the size of the
  409.  •        periodic chart just by making one change in the program.
  410.  •
  411.  •        Of course there are many other schemes to accomplish our task of drawing
  412.  •        a periodic chart and detecting in which element mouseclicks occur. While some
  413.  •        are much more elegant, I chose this one because it makes the algorithms for
  414.  •        drawing and detecting very explicit.
  415.  */
  416.  
  417.  /*
  418.  •        First we construct column 1
  419.  */
  420.  
  421.     PeriodicRects[1].left    =    26;                PeriodicRects[1].right        =    26    + BoxSize;
  422.     PeriodicRects[3].left    =    26;                PeriodicRects[3].right        =    26    + BoxSize;
  423.     PeriodicRects[11].left    =    26;                PeriodicRects[11].right        =    26    + BoxSize;
  424.     PeriodicRects[19].left    =    26;                PeriodicRects[19].right        =    26    + BoxSize;
  425.     PeriodicRects[37].left    =    26;                PeriodicRects[37].right        =    26    + BoxSize;
  426.     PeriodicRects[55].left    =    26;                PeriodicRects[55].right        =    26    + BoxSize;
  427.     PeriodicRects[87].left    =    26;                PeriodicRects[87].right        =    26    + BoxSize;
  428.  
  429.     PeriodicRects[1].top    =    26;                PeriodicRects[1].bottom        =    26    + BoxSize;
  430.     PeriodicRects[3].top    =    26 + 1*BoxSize;    PeriodicRects[3].bottom        =    26    + 2*BoxSize;
  431.     PeriodicRects[11].top    =    26 + 2*BoxSize;    PeriodicRects[11].bottom    =    26    + 3*BoxSize;
  432.     PeriodicRects[19].top    =    26 + 3*BoxSize;    PeriodicRects[19].bottom    =    26    + 4*BoxSize;
  433.     PeriodicRects[37].top    =    26 + 4*BoxSize;    PeriodicRects[37].bottom    =    26    + 5*BoxSize;
  434.     PeriodicRects[55].top    =    26 + 5*BoxSize;    PeriodicRects[55].bottom    =    26    + 6*BoxSize;
  435.     PeriodicRects[87].top    =    26 + 6*BoxSize;    PeriodicRects[87].bottom    =    26    + 7*BoxSize;
  436.  
  437. /*
  438. •        Then column 2
  439. */
  440.  
  441.     PeriodicRects[4].left    =    26 + BoxSize;    PeriodicRects[4].right        =    26    + 2*BoxSize;
  442.     PeriodicRects[12].left    =    26 + BoxSize;    PeriodicRects[12].right        =    26    + 2*BoxSize;
  443.     PeriodicRects[20].left    =    26 + BoxSize;    PeriodicRects[20].right        =    26    + 2*BoxSize;
  444.     PeriodicRects[38].left    =    26 + BoxSize;    PeriodicRects[38].right        =    26    + 2*BoxSize;
  445.     PeriodicRects[56].left    =    26 + BoxSize;    PeriodicRects[56].right        =    26    + 2*BoxSize;
  446.     PeriodicRects[88].left    =    26 + BoxSize;    PeriodicRects[88].right        =    26    + 2*BoxSize;
  447.  
  448.     PeriodicRects[4].top    =    26 + 1*BoxSize;    PeriodicRects[4].bottom        =    26    + 2*BoxSize;
  449.     PeriodicRects[12].top    =    26 + 2*BoxSize;    PeriodicRects[12].bottom    =    26    + 3*BoxSize;
  450.     PeriodicRects[20].top    =    26 + 3*BoxSize;    PeriodicRects[20].bottom    =    26    + 4*BoxSize;
  451.     PeriodicRects[38].top    =    26 + 4*BoxSize;    PeriodicRects[38].bottom    =    26    + 5*BoxSize;
  452.     PeriodicRects[56].top    =    26 + 5*BoxSize;    PeriodicRects[56].bottom    =    26    + 6*BoxSize;
  453.     PeriodicRects[88].top    =    26 + 6*BoxSize;    PeriodicRects[88].bottom    =    26    + 7*BoxSize;
  454.  
  455. /*
  456. •        And column 3
  457. */
  458.  
  459.     PeriodicRects[21].left    =    26 + 2*BoxSize;    PeriodicRects[21].right        =    26    + 3*BoxSize;
  460.     PeriodicRects[39].left    =    26 + 2*BoxSize;    PeriodicRects[39].right        =    26    + 3*BoxSize;
  461.     PeriodicRects[57].left    =    26 + 2*BoxSize;    PeriodicRects[57].right        =    26    + 3*BoxSize;
  462.     PeriodicRects[89].left    =    26 + 2*BoxSize;    PeriodicRects[89].right        =    26    + 3*BoxSize;
  463.  
  464.     PeriodicRects[21].top    =    26 + 3*BoxSize;    PeriodicRects[21].bottom    =    26    + 4*BoxSize;
  465.     PeriodicRects[39].top    =    26 + 4*BoxSize;    PeriodicRects[39].bottom    =    26    + 5*BoxSize;
  466.     PeriodicRects[57].top    =    26 + 5*BoxSize;    PeriodicRects[57].bottom    =    26    + 6*BoxSize;
  467.     PeriodicRects[89].top    =    26 + 6*BoxSize;    PeriodicRects[89].bottom    =    26    + 7*BoxSize;
  468.  
  469. /*
  470.  •        Now we use a for loop to construct the block of elements 22 thru 30,
  471.  •        40 thru 48, 72 thru 80, and 104 thru 112.
  472.  •
  473.  */
  474.     for    (loop1=0;loop1<9;loop1++)
  475.     {
  476.         PeriodicRects[loop1+22].left    =    26 + (3+loop1)*BoxSize;
  477.         PeriodicRects[loop1+40].left    =    PeriodicRects[loop1+22].left;
  478.         PeriodicRects[loop1+72].left    =    PeriodicRects[loop1+22].left;
  479.         PeriodicRects[loop1+104].left    =    PeriodicRects[loop1+22].left;
  480.         
  481.         PeriodicRects[loop1+22].right    =    PeriodicRects[loop1+22].left + BoxSize;
  482.         PeriodicRects[loop1+40].right    =    PeriodicRects[loop1+40].left + BoxSize;
  483.         PeriodicRects[loop1+72].right    =    PeriodicRects[loop1+72].left + BoxSize;
  484.         PeriodicRects[loop1+104].right    =    PeriodicRects[loop1+72].left + BoxSize;
  485.  
  486.         PeriodicRects[loop1+22].top        =    26 + 3*BoxSize;
  487.         PeriodicRects[loop1+40].top        =    26 + 4*BoxSize;
  488.         PeriodicRects[loop1+72].top        =    26 + 5*BoxSize;
  489.         PeriodicRects[loop1+104].top    =    26 + 6*BoxSize;
  490.  
  491.         PeriodicRects[loop1+22].bottom    =    26 + 4*BoxSize;
  492.         PeriodicRects[loop1+40].bottom    =    26 + 5*BoxSize;
  493.         PeriodicRects[loop1+72].bottom    =    26 + 6*BoxSize;
  494.         PeriodicRects[loop1+104].bottom    =    26 + 7*BoxSize;
  495.     }
  496.  
  497. /*
  498. •        Don't forget Helium!
  499. */
  500.  
  501.         PeriodicRects[2].left        =    26 + 17*BoxSize;
  502.         PeriodicRects[2].right        =    PeriodicRects[2].left  + BoxSize;
  503.         PeriodicRects[2].top        =    26;
  504.         PeriodicRects[2].bottom        =    26 + BoxSize;
  505.  
  506. /*
  507. •        And now for the rightmost six columns (starting with Boron and ending
  508. •        with Radon).
  509. */
  510.  
  511.     for    (loop1=0;loop1<6;loop1++)
  512.     {
  513.         PeriodicRects[loop1+5].left        =    26 + (12+loop1)*BoxSize;
  514.         PeriodicRects[loop1+13].left    =    PeriodicRects[loop1+5].left;
  515.         PeriodicRects[loop1+31].left    =    PeriodicRects[loop1+5].left;
  516.         PeriodicRects[loop1+49].left    =    PeriodicRects[loop1+5].left;
  517.         PeriodicRects[loop1+81].left    =    PeriodicRects[loop1+5].left;
  518.         
  519.         PeriodicRects[loop1+5].right    =    PeriodicRects[loop1+5].left  + BoxSize;
  520.         PeriodicRects[loop1+13].right    =    PeriodicRects[loop1+13].left + BoxSize;
  521.         PeriodicRects[loop1+31].right    =    PeriodicRects[loop1+31].left + BoxSize;
  522.         PeriodicRects[loop1+49].right    =    PeriodicRects[loop1+49].left + BoxSize;
  523.         PeriodicRects[loop1+81].right    =    PeriodicRects[loop1+81].left + BoxSize;
  524.  
  525.         PeriodicRects[loop1+5].top        =    26 + 1*BoxSize;
  526.         PeriodicRects[loop1+13].top        =    26 + 2*BoxSize;
  527.         PeriodicRects[loop1+31].top        =    26 + 3*BoxSize;
  528.         PeriodicRects[loop1+49].top        =    26 + 4*BoxSize;
  529.         PeriodicRects[loop1+81].top        =    26 + 5*BoxSize;
  530.  
  531.         PeriodicRects[loop1+5].bottom    =    26 + 2*BoxSize;
  532.         PeriodicRects[loop1+13].bottom    =    26 + 3*BoxSize;
  533.         PeriodicRects[loop1+31].bottom    =    26 + 4*BoxSize;
  534.         PeriodicRects[loop1+49].bottom    =    26 + 5*BoxSize;
  535.         PeriodicRects[loop1+81].bottom    =    26 + 6*BoxSize;
  536.     }
  537.  
  538. /*
  539. •        And at last Cerium thru Lutetuim and Thorium thru Lawrencium.
  540. */
  541.  
  542.     for    (loop1=0;loop1<14;loop1++)
  543.     {
  544.         PeriodicRects[loop1+58].left    =    26 + (3+loop1)*BoxSize;
  545.         PeriodicRects[loop1+90].left    =    PeriodicRects[loop1+58].left;
  546.         
  547.         PeriodicRects[loop1+58].right    =    PeriodicRects[loop1+58].left    + BoxSize;
  548.         PeriodicRects[loop1+90].right    =    PeriodicRects[loop1+90].left    + BoxSize;
  549.  
  550.         PeriodicRects[loop1+58].top        =    26 + 8*BoxSize;
  551.         PeriodicRects[loop1+90].top        =    26 + 9*BoxSize;
  552.  
  553.         PeriodicRects[loop1+58].bottom    =    26 + 9*BoxSize;
  554.         PeriodicRects[loop1+90].bottom    =    26 + 10*BoxSize;
  555.     }
  556.     
  557. /*
  558.  •        Now our scheme requires one small adjustment to the rects we have
  559.  •        constructed so our periodic chart will look right when we draw it.
  560.  •        QuickDraw coordinates are pure mathematical coordinates. That is,
  561.  •        a QuickDraw point is a mathematically pure, dimensionless point. It is
  562.  •        _not_ a pixel, which has a width (of 1) and height (of 1). FrameRect
  563.  •        does all of its drawing _inside_ the coordinates you specify. So we will
  564.  •        draw the row of pixels _above_ the boundary separating Hydrogen and Lithium
  565.  •        when we draw our Hydrogen box, and below the boundary when we
  566.  •        draw our Lithium box. That would make a line two pixels wide, which we
  567.  •        do not want. So we just increase the right and bottom of each rectangle
  568.  •        by one to make everything draw correctly.
  569.  •        
  570.  */
  571.  
  572.     for    (loop1=1;loop1<=Max_NumElements;loop1++)
  573.     {
  574.         PeriodicRects[loop1].right++;
  575.         PeriodicRects[loop1].bottom++;
  576.     }
  577.         
  578. }
  579.     
  580.                                     /*end Init_Variables()*/
  581.  
  582.     
  583.     
  584.     
  585.     
  586.     
  587.     
  588.     
  589.     
  590.     
  591.  
  592.